home *** CD-ROM | disk | FTP | other *** search
/ CD Actual Thematic 7: Programming / CDAT7.iso / demos / VisualAge for Java 2.0 Entry / setup / data1.cab / ide-e / IDE / cache / 3V7AJH (.txt) < prev    next >
Encoding:
Java Class File  |  1998-09-16  |  9.5 KB  |  491 lines

  1. package com.sun.java.swing;
  2.  
  3. import com.sun.java.swing.event.EventListenerList;
  4. import com.sun.java.swing.event.ListSelectionEvent;
  5. import com.sun.java.swing.event.ListSelectionListener;
  6. import java.io.Serializable;
  7. import java.util.BitSet;
  8.  
  9. public class DefaultListSelectionModel implements ListSelectionModel, Cloneable, Serializable {
  10.    private int selectionMode = 2;
  11.    private int minIndex = -1;
  12.    private int maxIndex = -1;
  13.    private int anchorIndex = -1;
  14.    private int leadIndex = -1;
  15.    private int firstChangedIndex = -1;
  16.    private int lastChangedIndex = -1;
  17.    private boolean isAdjusting = false;
  18.    protected BitSet value = new BitSet(32);
  19.    protected EventListenerList listenerList = new EventListenerList();
  20.    protected boolean leadAnchorNotificationEnabled = true;
  21.    static Class class$com$sun$java$swing$event$ListSelectionListener;
  22.  
  23.    public void addListSelectionListener(ListSelectionListener l) {
  24.       EventListenerList var10000 = this.listenerList;
  25.       Class var10001 = class$com$sun$java$swing$event$ListSelectionListener;
  26.       if (var10001 == null) {
  27.          try {
  28.             var10001 = Class.forName("com.sun.java.swing.event.ListSelectionListener");
  29.          } catch (ClassNotFoundException var2) {
  30.             throw new NoClassDefFoundError(((Throwable)var2).getMessage());
  31.          }
  32.  
  33.          class$com$sun$java$swing$event$ListSelectionListener = var10001;
  34.       }
  35.  
  36.       var10000.add(var10001, l);
  37.    }
  38.  
  39.    public void addSelectionInterval(int index0, int index1) {
  40.       int mode = this.getSelectionMode();
  41.       if (mode != 0 && mode != 1) {
  42.          if (index0 != -1 || index1 != -1) {
  43.             int addMinIndex = Math.min(index0, index1);
  44.             int addMaxIndex = Math.max(index0, index1);
  45.             if (this.minIndex == -1 || addMinIndex < this.minIndex) {
  46.                this.minIndex = addMinIndex;
  47.             }
  48.  
  49.             if (this.maxIndex == -1 || addMaxIndex > this.maxIndex) {
  50.                this.maxIndex = addMaxIndex;
  51.             }
  52.  
  53.             this.firstChangedIndex = -1;
  54.             this.lastChangedIndex = -1;
  55.  
  56.             for(int r = addMinIndex; r <= addMaxIndex; ++r) {
  57.                if (!this.value.get(r)) {
  58.                   if (this.firstChangedIndex == -1) {
  59.                      this.firstChangedIndex = this.lastChangedIndex = r;
  60.                   } else if (r > this.lastChangedIndex) {
  61.                      this.lastChangedIndex = r;
  62.                   }
  63.  
  64.                   this.value.set(r);
  65.                }
  66.             }
  67.  
  68.             this.updateLeadAnchorIndices(index0, index1);
  69.             if (this.firstChangedIndex != -1 && this.lastChangedIndex != -1) {
  70.                this.fireValueChanged(this.firstChangedIndex, this.lastChangedIndex);
  71.             }
  72.  
  73.          }
  74.       } else {
  75.          this.setSelectionInterval(index0, index1);
  76.       }
  77.    }
  78.  
  79.    public void clearSelection() {
  80.       if (this.minIndex != -1 && this.maxIndex != -1) {
  81.          boolean selectionChanged = false;
  82.  
  83.          for(int r = this.minIndex; r <= this.maxIndex; ++r) {
  84.             if (this.value.get(r)) {
  85.                selectionChanged = true;
  86.             }
  87.  
  88.             this.value.clear(r);
  89.          }
  90.  
  91.          this.minIndex = this.maxIndex = this.anchorIndex = this.leadIndex = -1;
  92.          if (selectionChanged) {
  93.             this.fireValueChanged(this.minIndex, this.maxIndex);
  94.          }
  95.  
  96.       }
  97.    }
  98.  
  99.    public Object clone() throws CloneNotSupportedException {
  100.       DefaultListSelectionModel clone = (DefaultListSelectionModel)super.clone();
  101.       clone.value = (BitSet)this.value.clone();
  102.       clone.listenerList = new EventListenerList();
  103.       return clone;
  104.    }
  105.  
  106.    private boolean contains(int a, int b, int index) {
  107.       if (a <= b) {
  108.          return index >= a && index < b;
  109.       } else {
  110.          return index <= a && index > b;
  111.       }
  112.    }
  113.  
  114.    protected void fireValueChanged(int firstIndex, int lastIndex) {
  115.       this.fireValueChanged(firstIndex, lastIndex, this.getValueIsAdjusting());
  116.    }
  117.  
  118.    protected void fireValueChanged(int firstIndex, int lastIndex, boolean isAdjusting) {
  119.       Object[] listeners = this.listenerList.getListenerList();
  120.       ListSelectionEvent e = null;
  121.  
  122.       for(int i = listeners.length - 2; i >= 0; i -= 2) {
  123.          Object var10000 = listeners[i];
  124.          Class var10001 = class$com$sun$java$swing$event$ListSelectionListener;
  125.          if (var10001 == null) {
  126.             try {
  127.                var10001 = Class.forName("com.sun.java.swing.event.ListSelectionListener");
  128.             } catch (ClassNotFoundException var7) {
  129.                throw new NoClassDefFoundError(((Throwable)var7).getMessage());
  130.             }
  131.  
  132.             class$com$sun$java$swing$event$ListSelectionListener = var10001;
  133.          }
  134.  
  135.          if (var10000 == var10001) {
  136.             if (e == null) {
  137.                e = new ListSelectionEvent(this, firstIndex, lastIndex, isAdjusting);
  138.             }
  139.  
  140.             ((ListSelectionListener)listeners[i + 1]).valueChanged(e);
  141.          }
  142.       }
  143.  
  144.    }
  145.  
  146.    protected void fireValueChanged(boolean isAdjusting) {
  147.       this.fireValueChanged(this.getMinSelectionIndex(), this.getMaxSelectionIndex(), isAdjusting);
  148.    }
  149.  
  150.    public int getAnchorSelectionIndex() {
  151.       return this.anchorIndex;
  152.    }
  153.  
  154.    public int getLeadSelectionIndex() {
  155.       return this.leadIndex;
  156.    }
  157.  
  158.    public int getMaxSelectionIndex() {
  159.       return this.maxIndex;
  160.    }
  161.  
  162.    public int getMinSelectionIndex() {
  163.       return this.minIndex;
  164.    }
  165.  
  166.    public int getSelectionMode() {
  167.       return this.selectionMode;
  168.    }
  169.  
  170.    public boolean getValueIsAdjusting() {
  171.       return this.isAdjusting;
  172.    }
  173.  
  174.    public void insertIndexInterval(int index, int length, boolean before) {
  175.       int insMinIndex = before ? Math.max(0, index - 1) : index + 1;
  176.       int insMaxIndex = insMinIndex + length - 1;
  177.       boolean selected = this.value.get(index) && this.value.get(insMinIndex);
  178.  
  179.       for(int i = this.maxIndex; i >= insMinIndex; --i) {
  180.          if (this.value.get(i)) {
  181.             this.value.set(i + length);
  182.          } else {
  183.             this.value.clear(i + length);
  184.          }
  185.       }
  186.  
  187.       for(int i = insMinIndex; i <= insMaxIndex; ++i) {
  188.          if (selected) {
  189.             this.value.set(i);
  190.          } else {
  191.             this.value.clear(i);
  192.          }
  193.       }
  194.  
  195.       if (this.minIndex != -1 && (this.minIndex > insMinIndex || this.minIndex == insMinIndex && !selected)) {
  196.          this.minIndex += length;
  197.       }
  198.  
  199.       if (this.maxIndex != -1 && this.maxIndex >= insMinIndex) {
  200.          this.maxIndex += length;
  201.       }
  202.  
  203.       this.fireValueChanged(insMinIndex, this.maxIndex);
  204.    }
  205.  
  206.    public boolean isLeadAnchorNotificationEnabled() {
  207.       return this.leadAnchorNotificationEnabled;
  208.    }
  209.  
  210.    public boolean isSelectedIndex(int index) {
  211.       return index != -1 && index >= this.minIndex && index <= this.maxIndex ? this.value.get(index) : false;
  212.    }
  213.  
  214.    public boolean isSelectionEmpty() {
  215.       return this.minIndex == -1 && this.maxIndex == -1;
  216.    }
  217.  
  218.    public void removeIndexInterval(int index0, int index1) {
  219.       if (index0 >= 0 && index1 >= 0) {
  220.          if (this.minIndex != -1 || this.maxIndex != -1) {
  221.             int rmMinIndex = Math.min(index0, index1);
  222.             int rmMaxIndex = Math.max(index0, index1);
  223.             int gapLength = rmMaxIndex - rmMinIndex + 1;
  224.             if (rmMinIndex <= this.maxIndex && rmMaxIndex >= this.minIndex) {
  225.                if (rmMinIndex <= this.minIndex && rmMaxIndex >= this.maxIndex) {
  226.                   this.clearSelection();
  227.                } else {
  228.                   for(int i = rmMinIndex; i <= rmMaxIndex; ++i) {
  229.                      if (this.value.get(i + gapLength)) {
  230.                         this.value.set(i);
  231.                      } else {
  232.                         this.value.clear(i);
  233.                      }
  234.                   }
  235.  
  236.                   for(int i = this.maxIndex; i > this.maxIndex - gapLength; --i) {
  237.                      this.value.clear(i);
  238.                   }
  239.  
  240.                   int oldMinIndex = this.minIndex;
  241.                   int oldMaxIndex = this.maxIndex;
  242.                   if (oldMinIndex >= rmMinIndex) {
  243.                      this.minIndex = -1;
  244.  
  245.                      for(int i = rmMinIndex; i <= oldMaxIndex; ++i) {
  246.                         if (this.value.get(i)) {
  247.                            this.minIndex = i;
  248.                            break;
  249.                         }
  250.                      }
  251.                   }
  252.  
  253.                   if (this.minIndex == -1) {
  254.                      this.maxIndex = -1;
  255.                   } else if (oldMaxIndex > rmMaxIndex) {
  256.                      this.maxIndex = oldMaxIndex - gapLength;
  257.                   } else {
  258.                      for(int i = oldMaxIndex; i >= this.minIndex; --i) {
  259.                         if (this.value.get(i)) {
  260.                            this.maxIndex = i;
  261.                            break;
  262.                         }
  263.                      }
  264.                   }
  265.  
  266.                   if (this.maxIndex == -1 && this.minIndex == -1) {
  267.                      this.fireValueChanged(rmMinIndex, rmMaxIndex);
  268.                   } else {
  269.                      this.firstChangedIndex = Math.min(rmMinIndex, this.minIndex);
  270.                      this.lastChangedIndex = Math.max(rmMaxIndex, this.maxIndex);
  271.                      this.fireValueChanged(this.firstChangedIndex, this.lastChangedIndex);
  272.                   }
  273.  
  274.                }
  275.             }
  276.          }
  277.       }
  278.    }
  279.  
  280.    public void removeListSelectionListener(ListSelectionListener l) {
  281.       EventListenerList var10000 = this.listenerList;
  282.       Class var10001 = class$com$sun$java$swing$event$ListSelectionListener;
  283.       if (var10001 == null) {
  284.          try {
  285.             var10001 = Class.forName("com.sun.java.swing.event.ListSelectionListener");
  286.          } catch (ClassNotFoundException var2) {
  287.             throw new NoClassDefFoundError(((Throwable)var2).getMessage());
  288.          }
  289.  
  290.          class$com$sun$java$swing$event$ListSelectionListener = var10001;
  291.       }
  292.  
  293.       var10000.remove(var10001, l);
  294.    }
  295.  
  296.    public void removeSelectionInterval(int index0, int index1) {
  297.       if (index0 != -1 || index1 != -1) {
  298.          if (this.minIndex != -1 || this.maxIndex != -1) {
  299.             int remMinIndex = Math.min(index0, index1);
  300.             int remMaxIndex = Math.max(index0, index1);
  301.             int firstChangedIndex = -1;
  302.             int lastChangedIndex = -1;
  303.  
  304.             for(int r = remMinIndex; r <= remMaxIndex; ++r) {
  305.                if (this.value.get(r)) {
  306.                   if (firstChangedIndex == -1) {
  307.                      lastChangedIndex = r;
  308.                      firstChangedIndex = r;
  309.                   } else if (r > lastChangedIndex) {
  310.                      lastChangedIndex = r;
  311.                   }
  312.  
  313.                   this.value.clear(r);
  314.                }
  315.             }
  316.  
  317.             int newMinIndex = -1;
  318.             int newMaxIndex = -1;
  319.  
  320.             for(int r = this.minIndex; r <= this.maxIndex; ++r) {
  321.                if (this.value.get(r)) {
  322.                   if (newMinIndex == -1) {
  323.                      newMaxIndex = r;
  324.                      newMinIndex = r;
  325.                   } else if (r > newMaxIndex) {
  326.                      newMaxIndex = r;
  327.                   }
  328.                }
  329.             }
  330.  
  331.             this.minIndex = newMinIndex;
  332.             this.maxIndex = newMaxIndex;
  333.             if (firstChangedIndex != -1 && lastChangedIndex != -1) {
  334.                this.fireValueChanged(firstChangedIndex, lastChangedIndex);
  335.             }
  336.  
  337.          }
  338.       }
  339.    }
  340.  
  341.    public void setAnchorSelectionIndex(int index) {
  342.       this.anchorIndex = index;
  343.    }
  344.  
  345.    public void setLeadAnchorNotificationEnabled(boolean flag) {
  346.       this.leadAnchorNotificationEnabled = flag;
  347.    }
  348.  
  349.    public void setLeadSelectionIndex(int index) {
  350.       this.updateLead(index);
  351.       this.leadIndex = index;
  352.    }
  353.  
  354.    public void setSelectionInterval(int index0, int index1) {
  355.       if (this.getSelectionMode() == 0) {
  356.          index0 = index1;
  357.       }
  358.  
  359.       if (index0 == -1 && index1 == -1) {
  360.          this.clearSelection();
  361.       } else {
  362.          int newMinIndex = Math.min(index0, index1);
  363.          int newMaxIndex = Math.max(index0, index1);
  364.          if (this.minIndex == -1 || newMinIndex < this.minIndex) {
  365.             this.minIndex = newMinIndex;
  366.          }
  367.  
  368.          if (this.maxIndex == -1 || newMaxIndex > this.maxIndex) {
  369.             this.maxIndex = newMaxIndex;
  370.          }
  371.  
  372.          this.firstChangedIndex = -1;
  373.          this.lastChangedIndex = -1;
  374.  
  375.          for(int r = this.minIndex; r < newMinIndex; ++r) {
  376.             if (this.value.get(r)) {
  377.                if (this.firstChangedIndex == -1) {
  378.                   this.firstChangedIndex = this.lastChangedIndex = r;
  379.                } else if (r > this.lastChangedIndex) {
  380.                   this.lastChangedIndex = r;
  381.                }
  382.             }
  383.  
  384.             this.value.clear(r);
  385.          }
  386.  
  387.          for(int r = newMinIndex; r <= newMaxIndex; ++r) {
  388.             if (!this.value.get(r)) {
  389.                if (this.firstChangedIndex == -1) {
  390.                   this.firstChangedIndex = this.lastChangedIndex = r;
  391.                } else if (r > this.lastChangedIndex) {
  392.                   this.lastChangedIndex = r;
  393.                }
  394.             }
  395.  
  396.             this.value.set(r);
  397.          }
  398.  
  399.          for(int r = newMaxIndex + 1; r <= this.maxIndex; ++r) {
  400.             if (this.value.get(r)) {
  401.                if (this.firstChangedIndex == -1) {
  402.                   this.firstChangedIndex = this.lastChangedIndex = r;
  403.                } else if (r > this.lastChangedIndex) {
  404.                   this.lastChangedIndex = r;
  405.                }
  406.             }
  407.  
  408.             this.value.clear(r);
  409.          }
  410.  
  411.          this.updateLeadAnchorIndices(index0, index1);
  412.          this.minIndex = newMinIndex;
  413.          this.maxIndex = newMaxIndex;
  414.          if (this.firstChangedIndex != -1 && this.lastChangedIndex != -1) {
  415.             this.fireValueChanged(this.firstChangedIndex, this.lastChangedIndex);
  416.          }
  417.  
  418.       }
  419.    }
  420.  
  421.    public void setSelectionMode(int selectionMode) {
  422.       switch (selectionMode) {
  423.          case 0:
  424.          case 1:
  425.          case 2:
  426.             this.selectionMode = selectionMode;
  427.             return;
  428.          default:
  429.             throw new IllegalArgumentException("invalid selectionMode");
  430.       }
  431.    }
  432.  
  433.    public void setValueIsAdjusting(boolean b) {
  434.       if (b != this.isAdjusting) {
  435.          this.isAdjusting = b;
  436.          this.fireValueChanged(b);
  437.       }
  438.  
  439.    }
  440.  
  441.    private int sign(int a, int b) {
  442.       return a < b ? -1 : (a > b ? 1 : 0);
  443.    }
  444.  
  445.    public String toString() {
  446.       String s = (this.getValueIsAdjusting() ? "~" : "=") + this.value.toString();
  447.       return this.getClass().getName() + " " + Integer.toString(this.hashCode()) + " " + s;
  448.    }
  449.  
  450.    private void updateLead(int index) {
  451.       if (this.anchorIndex == -1) {
  452.          this.anchorIndex = index;
  453.       }
  454.  
  455.       boolean deselect = false;
  456.       if (!deselect && this.contains(this.leadIndex, index, this.anchorIndex)) {
  457.          this.removeSelectionInterval(this.anchorIndex, this.leadIndex);
  458.          this.addSelectionInterval(this.anchorIndex, index);
  459.       }
  460.  
  461.       if (!deselect && !this.contains(this.anchorIndex, this.leadIndex, index)) {
  462.          this.addSelectionInterval(this.anchorIndex, index);
  463.       } else {
  464.          int delta = this.sign(this.anchorIndex, this.leadIndex);
  465.          this.removeSelectionInterval(index - delta, this.leadIndex);
  466.       }
  467.  
  468.    }
  469.  
  470.    private void updateLeadAnchorIndices(int index0, int index1) {
  471.       if (this.leadAnchorNotificationEnabled) {
  472.          if (this.anchorIndex != -1 && this.anchorIndex != index0) {
  473.             int minAnchorIndex = Math.min(this.anchorIndex, index0);
  474.             int maxAnchorIndex = Math.max(this.anchorIndex, index0);
  475.             this.firstChangedIndex = this.firstChangedIndex == -1 ? maxAnchorIndex : Math.min(minAnchorIndex, this.firstChangedIndex);
  476.             this.lastChangedIndex = Math.max(maxAnchorIndex, this.lastChangedIndex);
  477.          }
  478.  
  479.          if (this.leadIndex != -1 && this.leadIndex != index1) {
  480.             int minLeadIndex = Math.min(this.leadIndex, index1);
  481.             int maxLeadIndex = Math.max(this.leadIndex, index1);
  482.             this.firstChangedIndex = this.firstChangedIndex == -1 ? minLeadIndex : Math.min(minLeadIndex, this.firstChangedIndex);
  483.             this.lastChangedIndex = Math.max(maxLeadIndex, this.lastChangedIndex);
  484.          }
  485.       }
  486.  
  487.       this.anchorIndex = index0;
  488.       this.leadIndex = index1;
  489.    }
  490. }
  491.